#include "linked_list.hpp"
#include <string.h>


Node::Node(DataType *data, DataType data_size) : data{new DataType[data_size]{}}, data_size{data_size}, next{nullptr}
{
    memcpy(this->data, data, sizeof(DataType) * data_size);
    cout << "Node constructor" << endl;
}
Node::Node(const Node &node) : data{new DataType[node.data_size]{}}, data_size{node.data_size}, next{new Node{node.next->get_data(), node.next->get_data_size()}}
{
    // this->next = new Node{node.next->get_data_size()};
    memcpy(this->data, node.data, sizeof(DataType) * node.data_size);
    cout << "Node copy constructor" << endl;
}
Node::~Node()
{
    cout << "Node destructor" << endl;
    delete[] data;
    data = nullptr;
    data_size = 0;
    next = nullptr;

}
DataType Node::get_data_size()const
{
    return data_size;
}
DataType *Node::get_data()const
{
    return data;
}
Node *Node::get_next()const
{
    return next;
}
bool Node::set_next(Node *next)
{
    this->next = next;
    return true;
}
bool Node::set_data(DataType *data, DataType data_size)
{
    if (data == nullptr || data_size == 0)
    {
        return false;
    }
    
    // this->data = data;
    memcpy(this->data, data, sizeof(DataType) * data_size);
    this->data_size = data_size;
    return true;
}
Linked_list::Linked_list() : head{nullptr}, tail{nullptr}, size{0}
{
    cout << "Linked_list constructor" << endl; 
}
Linked_list::Linked_list(DataType *data, DataType data_size, DataType size) : head{nullptr}, tail{nullptr}, size{size}
{
    cout << "Linked_list constructor" << endl; 
} 

Linked_list::Linked_list(const Linked_list &list) : head{new Node{list.head->get_data(), list.head->get_data_size()}}, tail{ new Node{list.head->get_data(),list.head->get_data_size()}}, size{list.size}
{
    cout << "Linked_list copy constructor" << endl;

}
Linked_list::~Linked_list()
{
    cout << "Linked_list destructor" << endl;
    Linked_list::clear();
}
bool Linked_list::is_empty()
{
    return size == 0;
}
bool Linked_list::index_boundary(DataType index)const
{
    if (index < 0 || index >= size)
    {
        return false;
    }
    return true;
}
bool Linked_list::clear()
{
    if (head)
    {
        Node *p = head;
        while (p)
        {
            Node *temp = p;
            p = p->get_next();
            delete temp;// 只是清除数据 但指针还在
        }
        head = nullptr;
        // cout << tail << endl;
        tail = nullptr;
    }
    size = 0;
}
bool Linked_list::insert(DataType *data, DataType data_size)
{
    // 创建一个新节点
    Node *new_node = new Node{data, data_size};
    if (head == nullptr)// 第一次
    {
        head = new_node;
        tail = new_node;
        size++;
        return true;
    }
    // 头插插入头节点之前 后头节点改变位置指向新节点 相反的数据
    // new_node->set_next(head);
    // head = new_node;
    // 尾插插入尾节点之后 尾节点指向新节点
    tail->set_next(new_node);
    tail = new_node;

    size++;
    return true;
}
bool Linked_list::insert(DataType index, DataType *data, DataType data_size)
{
    if (!index_boundary(index))
    {
        return false;
    }
    // 创建即将插入的新节点
    Node *new_node = new Node{data, data_size};
    // 寻找插入位置（当前位置的后一个位置）
    Node *p =head;
    Node *prev = head;
    while (index--)
    {
        prev = p;
        p = p->get_next();
    }
    // 插入节点（当前位置的后一个位置）
    // new_node->set_next(p->get_next());
    // p->set_next(new_node);
    // 插入到当前位置
    new_node->set_next(p);
    prev->set_next(new_node);
    size++;
    return true;
}
bool Linked_list::remove(DataType index)
{
    if (!index_boundary(index))
    {
        return false;
    }
    // 寻找删除位置（当前位置）
    Node *p =head;
    Node *prev = head;
    while (index--)
    {
        prev = p;
        p = p->get_next();
    }
    // 删除节点
    prev->set_next(p->get_next());
    delete p;
    p = nullptr;
    size--;
    return true;
}
DataType *Linked_list::get_data(DataType index)const
{
    if (!index_boundary(index))
    {
        return nullptr;
    }
    // 寻找当前位置的节点（当前位置）
    Node *p =head;
    Node *prev = head;
    while (index--)
    {
        prev = p;
        p = p->get_next();
    }
    // 返回当前位置的节点的数据
    return p->get_data();
}
DataType Linked_list::get_size()const
{
    return size;
}
DataType *Linked_list::get_head()const
{
    return head ? head->get_data() : NULL;
}
DataType *Linked_list::get_tail()const
{
    return tail ? tail->get_data() : NULL;
}
Node *Linked_list::get_node(DataType index)const
{
    if (!index_boundary(index))
    {
        return nullptr;
    }
    // 寻找当前位置的节点（当前位置）
    Node *p =head;
    Node *prev = head;
    while (index--)
    {
        prev = p;
        p = p->get_next();
    }
    // 返回当前位置的节点
    return p;
}
Node *Linked_list::get_next(DataType index)const
{
    if (!index_boundary(index))
    {
        return nullptr;
    }
    // 寻找当前位置的节点（当前位置）
    Node *p =head;
    Node *prev = head;
    while (index--)
    {
        prev = p;
        p = p->get_next();
    }
    // 返回当前位置的节点的下一个节点
    return p->get_next();
}
Node *Linked_list::get_prev(DataType index)const
{
    if (!index_boundary(index))
    {
        return nullptr;
    }
    // 寻找当前位置的节点（当前位置）
    Node *p =head;
    Node *prev = head;
    while (index--)
    {
        prev = p;
        p = p->get_next();
    }
    // 返回当前位置的节点的上一个节点
    return prev;

}
void printf_data(DataType *data, DataType data_size)
{
    for (DataType i = 0; i < data_size; i++)
    {
        cout << data[i] << " ";
    }
    cout << endl;

}
void printf_list(Linked_list &list)
{
    cout << "head" << endl;
    // printf_data(head->get_data(), head->get_data_size());
    Node *p = list.head;
    while (p)
    {
        cout << p << "->" << p->get_data() << ":";
        printf_data(p->get_data(), p->get_data_size());
        p = p->get_next();
    }
    cout << "tail" << endl;
    // printf_data(tail->get_data(), tail->get_data_size());
}
// -fsanitize=address
int main()
{
    Linked_list list;
    DataType data[6][5] = {{1,2,3,4,5},{6,7,8,9,10},{11,12,13,14,15},{1,2,3,4,5},{6,7,8,9,10},{11,12,13,14,15} };
    for (DataType i = 0; i < 6; i++)
    {
        list.insert(data[i], 5);
    }
    printf_list(list);
    list.remove(2);
    printf_list(list);
    list.insert(2, data[2], 5);
    printf_list(list);
    cout << list.get_size() << endl;
    cout << list.get_head() << endl;
    cout << list.get_tail() << endl;
    cout << list.get_prev(2) << endl;
    cout << list.get_node(2) << endl;
    cout << list.get_next(2) << endl;
    cout << list.get_data(2) << ":";
    // 成员函数必须要用对象调用成员函数
    // list.Linked_list::printf_data(list.get_node(2)->get_data(), list.get_node(2)->get_data_size());
    printf_data(list.get_node(2)->get_data(), list.get_node(2)->get_data_size());

}
// 00000011 --> 00000010 --> 11111101 = 253

